Naukri Job Filter Automation: My Development Journey

Solution:

I used Chrome DevTools to inspect the DOM structure thoroughly. By examining job cards, pagination elements, and filter components, I identified stable CSS selectors that could reliably target the necessary elements. I documented these selectors meticulously to ensure the script's robustness.

Solution:

I developed a function to parse job cards and extract relevant details. The function used querySelector and querySelectorAll methods with the previously identified selectors, and included fallback logic for missing information.

extractJobDetails(jobCard) {
    try {
        // Job ID
        const jobId = jobCard.getAttribute('data-job-id') || 'N/A';
        
        // Job Title
        const titleElement = jobCard.querySelector('.title');
        const jobTitle = titleElement ? titleElement.textContent.trim() : 'N/A';
        const jobLink = titleElement ? titleElement.getAttribute('href') : 'N/A';
        
        // Company Name
        const companyElement = jobCard.querySelector('.comp-name');
        const companyName = companyElement ? companyElement.textContent.trim() : 'N/A';
        
        // Rating
        const ratingElement = jobCard.querySelector('.rating .main-2');
        const rating = ratingElement ? ratingElement.textContent.trim() : 'N/A';
        
        // Experience
        const expElement = jobCard.querySelector('.exp-wrap .expwdth');
        const experience = expElement ? expElement.textContent.trim() : 'N/A';
        
        // Salary
        const salaryElement = jobCard.querySelector('.sal-wrap span[title]');
        const salary = salaryElement ? salaryElement.getAttribute('title') : 'N/A';
        
        // Location
        const locationElement = jobCard.querySelector('.loc-wrap .locWdth');
        const location = locationElement ? locationElement.textContent.trim() : 'N/A';
        
        // Skills/Technologies
        const skillsElements = jobCard.querySelectorAll('.tags-gt .tag-li');
        const skills = Array.from(skillsElements).map(el => el.textContent.trim());
        
        // Posted Date
        const dateElement = jobCard.querySelector('.job-post-day');
        const postedDateText = dateElement ? dateElement.textContent.trim() : 'N/A';
        const postedDate = this.parsePostedDate(postedDateText);
        
        // Job Description (partial)
        const descElement = jobCard.querySelector('.job-desc');
        const description = descElement ? descElement.textContent.trim() : 'N/A';
        
        return {
        jobId,
        jobTitle,
        jobLink,
        companyName,
        rating,
        experience,
        salary,
        location,
        skills,
        postedDateText,
        postedDate,
        description
        };
    } catch (error) {
        console.error("Error extracting job details:", error);
        return null;
    }
}
                    

Solution:

I implemented a flexible matching algorithm that:

• Normalized text by converting to lowercase
• Searched for skills in multiple areas of the job listing
• Allowed for partial matches (e.g., "React" would match "ReactJS")
• Used a scoring system based on the number of matching skills

const combinedText = (description.toLowerCase() + ' ' + skills.join(' ').toLowerCase());


const hasAllRequiredSkills = (job, requiredSkills) => {
    if (!requiredSkills || requiredSkills.length === 0) {
        return true;
    }
    
    const combinedText = job.combinedText;
    
    // Check if all required skills are present in the combined text
    return requiredSkills.every(requiredSkill => {
        const requiredSkillLower = requiredSkill.toLowerCase().trim();
        return combinedText.includes(requiredSkillLower);
    });
    };

    config.requiredSkills = document.getElementById('skills-input').value
    .split(',')
    .map(s => s.trim())
    .filter(s => s.length > 0);
                                    

Solution:

I designed a floating control panel using pure JavaScript and CSS that would overlay on top of Naukri's interface. The panel included:

• A text input for required skills (comma-separated)
• A number input for minimum job rating
• A checkbox for including/excluding unrated jobs
• A number input for maximum pages to search
• Action buttons for filtering, multi-page search, and exporting results

Solution:

I implemented a pagination system that:

• Used the native "Next" button to navigate between pages
• Added delays between page transitions to mimic human behavior
• Parsed the pagination controls to determine the current page and total pages
• Stored collected job data across page transitions

const goToNextPage = () => {
    const nextButton = document.querySelector('.styles_btn-secondary__2AsIP:not(.styles_previous__PobAs)');
    if (nextButton && !nextButton.hasAttribute('disabled')) {
        console.log('Navigating to next page...');
        nextButton.click();
        return true;
    } else {
        console.log('Next button not available or disabled');
        return false;
    }
    };
                

Solution:

I added a visual progress bar to the control panel that updated in real-time as the script navigated through pages. The script also displayed the current page number and a running count of matching jobs found.

Solution:

I implemented an export function that:

• Formatted collected job data as CSV with proper escaping
• Created a Blob with the CSV content
• Generated a temporary download link using URL.createObjectURL
• Triggered a download with a meaningful filename including the search criteria and date

// Export matching jobs to CSV (for single page results)
const exportMatchingJobs = () => {
    const jobs = window.naukriMatchingJobs || [];
    
    if (!jobs || jobs.length === 0) {
    alert("No matching jobs to export");
    return;
    }
    
    // Get all unique fields from all job objects
    const excludeFields = ['element', 'postedDate', 'combinedText'];
    const allFields = new Set();
    
    jobs.forEach(job => {
    Object.keys(job).forEach(key => {
        if (!excludeFields.includes(key)) {
        allFields.add(key);
        }
    });
    });
    
    // Create CSV header row
    const fields = Array.from(allFields);
    let csv = fields.join(',') + '\n';
    
    // Add job data rows
    jobs.forEach(job => {
    const row = fields.map(field => {
        if (field === 'skills') {
        // Join skills array with semicolons
        return `"${job.skills ? job.skills.join('; ') : ''}"`;
        } else {
        // Escape quotes and wrap in quotes
        const value = job[field] !== undefined ? job[field] : '';
        return `"${String(value).replace(/"/g, '""')}"`;
        }
    }).join(',');
    
    csv += row + '\n';
    });
    
    // Create download link
    const blob = new Blob([csv], { type: 'text/csv;charset=utf-8;' });
    const url = URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.setAttribute('href', url);
    link.setAttribute('download', config.exportFilename);
    link.style.visibility = 'hidden';
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    
    console.log(`Exported ${jobs.length} jobs to ${config.exportFilename}`);
};
                                    

Solution:

I implemented comprehensive error handling and UI improvements:

• Added status messages for various scenarios (no results, search complete, etc.)
• Implemented timeouts for page loading with appropriate fallbacks
• Made the control panel collapsible and draggable
• Added visual indicators for matched jobs directly on the search results page

Solution:

I optimized the script by:

• Using more efficient DOM querying techniques
• Implementing debounced event handlers to prevent excessive function calls
• Removing features that weren't providing value